home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Utilities / Ghostscript / src / spdiff.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-01  |  12.4 KB  |  480 lines
  1. /* Copyright (C) 1994, 2000 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of AFPL Ghostscript.
  4.   
  5.   AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6.   distributor accepts any responsibility for the consequences of using it, or
  7.   for whether it serves any particular purpose or works at all, unless he or
  8.   she says so in writing.  Refer to the Aladdin Free Public License (the
  9.   "License") for full details.
  10.   
  11.   Every copy of AFPL Ghostscript must include a copy of the License, normally
  12.   in a plain ASCII text file named PUBLIC.  The License grants you the right
  13.   to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14.   conditions described in the License.  Among other things, the License
  15.   requires that the copyright notice and this notice be preserved on all
  16.   copies.
  17. */
  18.  
  19. /*$Id: spdiff.c,v 1.3 2000/09/19 19:00:51 lpd Exp $ */
  20. /* Pixel differencing filters */
  21. #include "stdio_.h"        /* should be std.h, but needs NULL */
  22. #include "memory_.h"
  23. #include "strimpl.h"
  24. #include "spdiffx.h"
  25.  
  26. /* ------ PixelDifferenceEncode/Decode ------ */
  27.  
  28. private_st_PDiff_state();
  29.  
  30. /* Define values for case dispatch. */
  31. #define cBits1 0
  32. #define cBits2 5
  33. #define cBits4 10
  34. #define cBits8 15
  35. #define cEncode 0
  36. #define cDecode 20
  37.  
  38. /* Set defaults */
  39. private void
  40. s_PDiff_set_defaults(stream_state * st)
  41. {
  42.     stream_PDiff_state *const ss = (stream_PDiff_state *) st;
  43.  
  44.     s_PDiff_set_defaults_inline(ss);
  45. }
  46.  
  47. /* Common (re)initialization. */
  48. private int
  49. s_PDiff_reinit(stream_state * st)
  50. {
  51.     stream_PDiff_state *const ss = (stream_PDiff_state *) st;
  52.  
  53.     ss->row_left = 0;
  54.     return 0;
  55. }
  56.  
  57. /* Initialize PixelDifferenceEncode filter. */
  58. private int
  59. s_PDiffE_init(stream_state * st)
  60. {
  61.     stream_PDiff_state *const ss = (stream_PDiff_state *) st;
  62.     int bits_per_row =
  63.     ss->Colors * ss->BitsPerComponent * ss->Columns;
  64.     static const byte cb_values[] = {
  65.     0, cBits1, cBits2, 0, cBits4, 0, 0, 0, cBits8
  66.     };
  67.  
  68.     ss->row_count = (bits_per_row + 7) >> 3;
  69.     ss->end_mask = (1 << (-bits_per_row & 7)) - 1;
  70.     ss->case_index =
  71.     cb_values[ss->BitsPerComponent] +
  72.     (ss->Colors > 4 ? 0 : ss->Colors) + cEncode;
  73.     return s_PDiff_reinit(st);
  74. }
  75.  
  76. /* Initialize PixelDifferenceDecode filter. */
  77. private int
  78. s_PDiffD_init(stream_state * st)
  79. {
  80.     stream_PDiff_state *const ss = (stream_PDiff_state *) st;
  81.  
  82.     s_PDiffE_init(st);
  83.     ss->case_index += cDecode - cEncode;
  84.     return 0;
  85. }
  86.  
  87. /* Process a buffer.  Note that this handles both Encode and Decode. */
  88. private int
  89. s_PDiff_process(stream_state * st, stream_cursor_read * pr,
  90.         stream_cursor_write * pw, bool last)
  91. {
  92.     stream_PDiff_state *const ss = (stream_PDiff_state *) st;
  93.     const byte *p = pr->ptr;
  94.     byte *q = pw->ptr;
  95.     int count;
  96.     int status = 0;
  97.     byte s0 = ss->prev[0];
  98.     byte t;
  99.     const byte end_mask = ss->end_mask;
  100.     int colors = ss->Colors;
  101.     int nb = (colors * ss->BitsPerComponent) >> 3;
  102.     int final;
  103.     int ndone, ci;
  104.  
  105. row:
  106.     if (ss->row_left == 0) {
  107.     ss->row_left = ss->row_count;
  108.     s0 = 0;
  109.     memset(ss->prev + 1, 0, s_PDiff_max_Colors - 1);
  110.     }
  111.     {
  112.     int rcount = pr->limit - p;
  113.     int wcount = pw->limit - q;
  114.  
  115.     if (ss->row_left < rcount)
  116.         rcount = ss->row_left;
  117.     count = (wcount < rcount ? (status = 1, wcount) : rcount);
  118.     }
  119.     final = (last && !status ? 1 : nb);
  120.     ss->row_left -= count;
  121.  
  122.     /*
  123.      * Encoding and decoding are fundamentally different.
  124.      * Encoding computes E[i] = D[i] - D[i-1];
  125.      * decoding computes D[i] = E[i] + D[i-1].
  126.      * Nevertheless, the loop structures are similar enough that
  127.      * we put the code for both functions in the same place.
  128.      *
  129.      * We only optimize BitsPerComponent = 1, 3, and 4, which
  130.      * correspond to the common color spaces.  (In some cases, it's still
  131.      * simpler to provide a separate loop for BPC = 2.)
  132.      */
  133.  
  134. #define LOOP_BY(n, body)\
  135.   for (; count >= n; count -= n) p += n, q += n, body
  136.  
  137.     switch (ss->case_index) {
  138.  
  139.         /* 1 bit per component */
  140.  
  141. #define ENCODE1_LOOP(ee)\
  142.   LOOP_BY(1, (t = *p, *q = ee, s0 = t)); break
  143.  
  144. #define ENCODE_ALIGNED_LOOP(ee)\
  145.   BEGIN\
  146.     ss->prev[0] = s0;\
  147.     for (; count >= final; count -= ndone) {\
  148.     ndone = min(count, nb);\
  149.     for (ci = 0; ci < ndone; ++ci)\
  150.         t = *++p, *++q = ee, ss->prev[ci] = t;\
  151.     }\
  152.     s0 = ss->prev[0];\
  153.   END
  154.  
  155. #define ENCODE_UNALIGNED_LOOP(shift, cshift, de)\
  156.   BEGIN\
  157.     for (; count >= final; count -= ndone) {\
  158.     ndone = min(count, nb);\
  159.     for (ci = 1; ci <= ndone; ++ci) {\
  160.         ++p;\
  161.         t = (s0 << (cshift)) | (ss->prev[ci] >> (shift));\
  162.         *++q = de;\
  163.         s0 = ss->prev[ci];\
  164.         ss->prev[ci] = *p;\
  165.     }\
  166.     }\
  167.   END
  168.  
  169.     case cEncode + cBits1 + 0:
  170.     case cEncode + cBits1 + 2:
  171.         if (colors < 8) {    /* 2,5,6,7 */
  172.         int cshift = 8 - colors;
  173.  
  174.         ENCODE1_LOOP(t ^ ((s0 << cshift) | (t >> colors)));
  175.         } else if (colors & 7) {
  176.         int shift = colors & 7;
  177.         int cshift = 8 - shift;
  178.  
  179.         ENCODE_UNALIGNED_LOOP(shift, cshift, *p ^ t);
  180.         } else {
  181.         ENCODE_ALIGNED_LOOP(t ^ ss->prev[ci]);
  182.         }
  183.         break;
  184.  
  185.     case cEncode + cBits1 + 1:
  186.         ENCODE1_LOOP(t ^ ((s0 << 7) | (t >> 1)));
  187.     case cEncode + cBits1 + 3:
  188.         ENCODE1_LOOP(t ^ ((s0 << 5) | (t >> 3)));
  189.     case cEncode + cBits1 + 4:
  190.         ENCODE1_LOOP(t ^ ((s0 << 4) | (t >> 4)));
  191.  
  192. #define DECODE1_LOOP(te, de)\
  193.   LOOP_BY(1, (t = te, s0 = *q = de)); break
  194.  
  195. #define DECODE_ALIGNED_LOOP(de)\
  196.   BEGIN\
  197.     ss->prev[0] = s0;\
  198.     for (; count >= final; count -= ndone) {\
  199.     ndone = min(count, nb);\
  200.     for (ci = 0; ci < ndone; ++ci)\
  201.         t = *++p, ss->prev[ci] = *++q = de;\
  202.     }\
  203.     s0 = ss->prev[0];\
  204.   END
  205.  
  206. #define DECODE_UNALIGNED_LOOP(shift, cshift, de)\
  207.   BEGIN\
  208.     for (; count >= final; count -= ndone) {\
  209.     ndone = min(count, nb);\
  210.     for (ci = 1; ci <= ndone; ++ci) {\
  211.         ++p, ++q;\
  212.         t = (s0 << (cshift)) | (ss->prev[ci] >> (shift));\
  213.         s0 = ss->prev[ci];\
  214.         ss->prev[ci] = *q = de;\
  215.     }\
  216.     }\
  217.   END
  218.  
  219.     case cDecode + cBits1 + 0:
  220.         if (colors < 8) {    /* 5,6,7 */
  221.         int cshift = 8 - colors;
  222.  
  223.         DECODE1_LOOP(*p ^ (s0 << cshift), t ^ (t >> colors));
  224.         } else if (colors & 7) {
  225.         int shift = colors & 7;
  226.         int cshift = 8 - shift;
  227.  
  228.         DECODE_UNALIGNED_LOOP(shift, cshift, *p ^ t);
  229.         } else {
  230.         DECODE_ALIGNED_LOOP(t ^ ss->prev[ci]);
  231.         }
  232.         break;
  233.  
  234.     case cDecode + cBits1 + 1:
  235.         DECODE1_LOOP(*p ^ (s0 << 7),
  236.              (t ^= t >> 1, t ^= t >> 2, t ^ (t >> 4)));
  237.     case cDecode + cBits1 + 2:
  238.         DECODE1_LOOP(*p ^ (s0 << 6),
  239.              (t ^= (t >> 2), t ^ (t >> 4)));
  240.     case cDecode + cBits1 + 3:
  241.         DECODE1_LOOP(*p ^ (s0 << 5),
  242.              t ^ (t >> 3) ^ (t >> 6));
  243.     case cDecode + cBits1 + 4:
  244.         DECODE1_LOOP(*p ^ (s0 << 4),
  245.              t ^ (t >> 4));
  246.  
  247.         /* 2 bits per component */
  248.  
  249. #define ADD4X2(a, b) ( (((a) & (b) & 0x55) << 1) ^ (a) ^ (b) )
  250. /* The following computation looks very implausible, but it is correct. */
  251. #define SUB4X2(a, b) ( ((~(a) & (b) & 0x55) << 1) ^ (a) ^ (b) )
  252.  
  253.     case cEncode + cBits2 + 0:
  254.         if (colors & 7) {
  255.         int shift = (colors & 3) << 1;
  256.         int cshift = 8 - shift;
  257.  
  258.         ENCODE_UNALIGNED_LOOP(shift, cshift, SUB4X2(*p, t));
  259.         } else {
  260.         ENCODE_ALIGNED_LOOP(SUB4X2(t, ss->prev[ci]));
  261.         }
  262.         break;
  263.  
  264.     case cEncode + cBits2 + 1:
  265.         ENCODE1_LOOP((s0 = (s0 << 6) | (t >> 2), SUB4X2(t, s0)));
  266.     case cEncode + cBits2 + 2:
  267.         ENCODE1_LOOP((s0 = (s0 << 4) | (t >> 4), SUB4X2(t, s0)));
  268.     case cEncode + cBits2 + 3:
  269.         ENCODE1_LOOP((s0 = (s0 << 2) | (t >> 6), SUB4X2(t, s0)));
  270.     case cEncode + cBits2 + 4:
  271.         ENCODE1_LOOP(SUB4X2(t, s0));
  272.  
  273.     case cDecode + cBits2 + 0:
  274.         if (colors & 7) {
  275.         int shift = (colors & 3) << 1;
  276.         int cshift = 8 - shift;
  277.  
  278.         DECODE_UNALIGNED_LOOP(shift, cshift, ADD4X2(*p, t));
  279.         } else {
  280.         DECODE_ALIGNED_LOOP(ADD4X2(t, ss->prev[ci]));
  281.         }
  282.         break;
  283.  
  284.     case cDecode + cBits2 + 1:
  285.         DECODE1_LOOP(*p + (s0 << 6),
  286.              (t = ADD4X2(t >> 2, t), ADD4X2(t >> 4, t)));
  287.     case cDecode + cBits2 + 2:
  288.         DECODE1_LOOP(*p, (t = ADD4X2(t, s0 << 4), ADD4X2(t >> 4, t)));
  289.     case cDecode + cBits2 + 3:
  290.         DECODE1_LOOP(*p, (t = ADD4X2(t, s0 << 2), ADD4X2(t >> 6, t)));
  291.     case cDecode + cBits2 + 4:
  292.         DECODE1_LOOP(*p, ADD4X2(t, s0));
  293.  
  294. #undef ADD4X2
  295. #undef SUB4X2
  296.  
  297.         /* 4 bits per component */
  298.  
  299. #define ADD2X4(a, b) ( (((a) + (b)) & 0xf) + ((a) & 0xf0) + ((b) & 0xf0) )
  300. #define ADD2X4R4(a) ( (((a) + ((a) >> 4)) & 0xf) + ((a) & 0xf0) )
  301. #define SUB2X4(a, b) ( (((a) - (b)) & 0xf) + ((a) & 0xf0) - ((b) & 0xf0) )
  302. #define SUB2X4R4(a) ( (((a) - ((a) >> 4)) & 0xf) + ((a) & 0xf0) )
  303.  
  304.     case cEncode + cBits4 + 0:
  305.     case cEncode + cBits4 + 2:
  306.     enc4:
  307.         if (colors & 1) {
  308.         ENCODE_UNALIGNED_LOOP(4, 4, SUB2X4(*p, t));
  309.         } else {
  310.         ENCODE_ALIGNED_LOOP(SUB2X4(t, ss->prev[ci]));
  311.         }
  312.         break;
  313.  
  314.     case cEncode + cBits4 + 1:
  315.         ENCODE1_LOOP(((t - (s0 << 4)) & 0xf0) | ((t - (t >> 4)) & 0xf));
  316.  
  317.     case cEncode + cBits4 + 3: {
  318.         byte s1 = ss->prev[1];
  319.  
  320.         LOOP_BY(1,
  321.             (t = *p,
  322.              *q = ((t - (s0 << 4)) & 0xf0) | ((t - (s1 >> 4)) & 0xf),
  323.              s0 = s1, s1 = t));
  324.         ss->prev[1] = s1;
  325.     } break;
  326.  
  327.     case cEncode + cBits4 + 4: {
  328.         byte s1 = ss->prev[1];
  329.  
  330.         LOOP_BY(2,
  331.             (t = p[-1], q[-1] = SUB2X4(t, s0), s0 = t,
  332.              t = *p, *q = SUB2X4(t, s1), s1 = t));
  333.         ss->prev[1] = s1;
  334.         goto enc4;        /* handle leftover bytes */
  335.     }
  336.  
  337.     case cDecode + cBits4 + 0:
  338.     case cDecode + cBits4 + 2:
  339.     dec4:
  340.         if (colors & 1) {
  341.         DECODE_UNALIGNED_LOOP(4, 4, ADD2X4(*p, t));
  342.         } else {
  343.         DECODE_ALIGNED_LOOP(ADD2X4(t, ss->prev[ci]));
  344.         }
  345.         break;
  346.  
  347.     case cDecode + cBits4 + 1:
  348.         DECODE1_LOOP(*p + (s0 << 4), ADD2X4R4(t));
  349.  
  350.     case cDecode + cBits4 + 3: {
  351.         byte s1 = ss->prev[1];
  352.  
  353.         LOOP_BY(1, (t = (s0 << 4) + (s1 >> 4),
  354.             s0 = s1, s1 = *q = ADD2X4(*p, t)));
  355.         ss->prev[1] = s1;
  356.     } break;
  357.  
  358.     case cDecode + cBits4 + 4: {
  359.         byte s1 = ss->prev[1];
  360.  
  361.         LOOP_BY(2,
  362.             (t = p[-1], s0 = q[-1] = ADD2X4(s0, t),
  363.              t = *p, s1 = *q = ADD2X4(s1, t)));
  364.         ss->prev[1] = s1;
  365.         goto dec4;        /* handle leftover bytes */
  366.     }
  367.  
  368. #undef ADD2X4
  369. #undef ADD2X4R4
  370. #undef SUB2X4
  371. #undef SUB2X4R4
  372.  
  373.         /* 8 bits per component */
  374.  
  375. #define ENCODE8(s, d) (q[d] = p[d] - s, s = p[d])
  376. #define DECODE8(s, d) q[d] = s += p[d]
  377.  
  378.     case cEncode + cBits8 + 0:
  379.     case cEncode + cBits8 + 2:
  380.         ss->prev[0] = s0;
  381.         for (; count >= colors; count -= colors)
  382.         for (ci = 0; ci < colors; ++ci) {
  383.             *++q = *++p - ss->prev[ci];
  384.             ss->prev[ci] = *p;
  385.         }
  386.         s0 = ss->prev[0];
  387.     enc8:   /* Handle leftover bytes. */
  388.         if (last && !status)
  389.         for (ci = 0; ci < count; ++ci)
  390.             *++q = *++p - ss->prev[ci],
  391.             ss->prev[ci] = *p;
  392.         break;
  393.  
  394.     case cDecode + cBits8 + 0:
  395.     case cDecode + cBits8 + 2:
  396.         ss->prev[0] = s0;
  397.         for (; count >= colors; count -= colors)
  398.         for (ci = 0; ci < colors; ++ci)
  399.             *++q = ss->prev[ci] += *++p;
  400.         s0 = ss->prev[0];
  401.     dec8:   /* Handle leftover bytes. */
  402.         if (last && !status)
  403.         for (ci = 0; ci < count; ++ci)
  404.             *++q = ss->prev[ci] += *++p;
  405.         break;
  406.  
  407.     case cEncode + cBits8 + 1:
  408.         LOOP_BY(1, ENCODE8(s0, 0));
  409.         break;
  410.  
  411.     case cDecode + cBits8 + 1:
  412.         LOOP_BY(1, DECODE8(s0, 0));
  413.         break;
  414.  
  415.     case cEncode + cBits8 + 3: {
  416.         byte s1 = ss->prev[1], s2 = ss->prev[2];
  417.  
  418.         LOOP_BY(3, (ENCODE8(s0, -2), ENCODE8(s1, -1),
  419.             ENCODE8(s2, 0)));
  420.         ss->prev[1] = s1, ss->prev[2] = s2;
  421.         goto enc8;
  422.     }
  423.  
  424.     case cDecode + cBits8 + 3: {
  425.         byte s1 = ss->prev[1], s2 = ss->prev[2];
  426.  
  427.         LOOP_BY(3, (DECODE8(s0, -2), DECODE8(s1, -1),
  428.             DECODE8(s2, 0)));
  429.         ss->prev[1] = s1, ss->prev[2] = s2;
  430.         goto dec8;
  431.     } break;
  432.  
  433.     case cEncode + cBits8 + 4: {
  434.         byte s1 = ss->prev[1], s2 = ss->prev[2], s3 = ss->prev[3];
  435.  
  436.         LOOP_BY(4, (ENCODE8(s0, -3), ENCODE8(s1, -2),
  437.             ENCODE8(s2, -1), ENCODE8(s3, 0)));
  438.         ss->prev[1] = s1, ss->prev[2] = s2, ss->prev[3] = s3;
  439.         goto enc8;
  440.     } break;
  441.  
  442.     case cDecode + cBits8 + 4: {
  443.         byte s1 = ss->prev[1], s2 = ss->prev[2], s3 = ss->prev[3];
  444.  
  445.         LOOP_BY(4, (DECODE8(s0, -3), DECODE8(s1, -2),
  446.             DECODE8(s2, -1), DECODE8(s3, 0)));
  447.         ss->prev[1] = s1, ss->prev[2] = s2, ss->prev[3] = s3;
  448.         goto dec8;
  449.     } break;
  450.  
  451. #undef ENCODE8
  452. #undef DECODE8
  453.  
  454.     }
  455. #undef LOOP_BY
  456. #undef ENCODE1_LOOP
  457. #undef DECODE1_LOOP
  458.     ss->row_left += count;    /* leftover bytes are possible */
  459.     if (ss->row_left == 0) {
  460.     if (end_mask != 0)
  461.         *q = (*q & ~end_mask) | (*p & end_mask);
  462.     if (p < pr->limit && q < pw->limit)
  463.         goto row;
  464.     }
  465.     ss->prev[0] = s0;
  466.     pr->ptr = p;
  467.     pw->ptr = q;
  468.     return status;
  469. }
  470.  
  471. /* Stream templates */
  472. const stream_template s_PDiffE_template = {
  473.     &st_PDiff_state, s_PDiffE_init, s_PDiff_process, 1, 1, NULL,
  474.     s_PDiff_set_defaults, s_PDiff_reinit
  475. };
  476. const stream_template s_PDiffD_template = {
  477.     &st_PDiff_state, s_PDiffD_init, s_PDiff_process, 1, 1, NULL,
  478.     s_PDiff_set_defaults, s_PDiff_reinit
  479. };
  480.